package entornos;
import java.io.*;

public class MiRandom extends Object implements Serializable {

	private void writeObject(java.io.ObjectOutputStream out) throws IOException {
	}

	private void readObject(ObjectInputStream in) throws IOException,
			ClassNotFoundException {
	}

	private void readObjectNoData() throws ObjectStreamException {
	}

	/**
	 * Creates a new random number generator. This constructor sets the seed of
	 * the random number generator to a value very likely to be distinct from
	 * any other invocation of this constructor.
	 */
	public void Random() {
	}

	/**
	 * Creates a new random number generator using a single long seed. The seed
	 * is the initial value of the internal state of the pseudorandom number
	 * generator which is maintained by method next(int).
	 * <p>
	 * The invocation new Random(seed) is equivalent to:
	 * </p>
	 * <code>
	 * Random rnd = new Random(); <p>rnd.setSeed(seed); </p>
	 * </code>
	 * 
	 * @param seed
	 *            the initial seed
	 * @See Also setSeed(long)
	 */
	public void Random(long seed) {
	}

	/**
	 * Sets the seed of this random number generator using a single long seed.
	 * The general contract of setSeed is that it alters the state of this
	 * random number generator object so as to be in exactly the same state as
	 * if it had just been created with the argument seed as a seed. The method
	 * setSeed is implemented by class Random by atomically updating the seed to
	 * <p>
	 * <code> 
	 * (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1)
	 * </code>
	 * </p>
	 * and clearing the haveNextNextGaussian flag used by nextGaussian().
	 * <p>
	 * The implementation of setSeed by class Random happens to use only 48 bits
	 * of the given seed. In general, however, an overriding method may use all
	 * 64 bits of the long argument as a seed value.
	 * </p>
	 * 
	 * @param seed
	 *            the initial seed
	 */
	public void setSeed(long seed) {
	}

	/**
	 * Generates the next pseudorandom number. Subclasses should override this,
	 * as this is used by all other methods.
	 * <p>
	 * The general contract of next is that it returns an int value and if the
	 * argument bits is between 1 and 32 (inclusive), then that many low-order
	 * bits of the returned value will be (approximately) independently chosen
	 * bit values, each of which is (approximately) equally likely to be 0 or 1.
	 * The method next is implemented by class Random by atomically updating the
	 * seed to
	 * </p>
	 * <p>
	 * <code> 
	 * (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1) 
	 * </code>
	 * </p>
	 * and returning
	 * <p>
	 * <code> 
	 * (int)(seed >>> (48 - bits)). 
	 * </code>
	 * </p>
	 * This is a linear congruential pseudorandom number generator, as defined
	 * by D. H. Lehmer and described by Donald E. Knuth in The Art of Computer
	 * Programming, Volume 3: Seminumerical Algorithms, section 3.2.1.
	 * 
	 * @param bits
	 *            random bits
	 * @return the next pseudorandom value from this random number generator's
	 *         sequence.
	 */
	protected int next(int bits) {
		return 0;
	}
	/**
	 * 
	 * @param bytes
	 */
	public void nextBytes(byte[] bytes) {
	}
}
